Lua strings are not UTF-8 and so it is incorrect to use Rust
strings. In particular, some Lua libraries specifically designed
to add support for Unicode, like ustring, use `string.find` to look
for non-ASCII characters in Lua strings, which is impossible to do
when Lua strings are treated as UTF-8 (a character set of
`[\x80-\xff]` is ill-formed).

This is an API-breaking change.

Note that downstream consumers like piccolo will now convert using
`IntoValue for Vec<T>` instead of `IntoValue for StdString` and
so those need to be changed to call `ctx.intern` explicitly instead
of relying on the auto-conversion.

PIL 20.2: An upper case version of any of those classes represents
the complement of the class.

Because this changes the signature of an exported function to
remove an unnecessary `Result` and a struct to eliminate an
unnecessary `Box`, this patch contains API-breaking changes.

This makes the replacement method agnostic to whatever type the
consumer is using instead of requiring the table to be collected
into a `HashMap`.

This is an API-breaking change.

Lua 5.4 § 6.4.1:

> As a special case, the capture () captures the current string
> position (a number). For instance, if we apply the pattern
> "()aa()" on the string "flaaap", there will be two captures: 3
> and 5.

Closely associated types can be stored in the same module. This
reduces the amount of re-exporting that has to happen to get
everything out, reduces file switching during development, and
may decrease the chance of creating confusing type name conflicts.

Due to current non-conformance in the engine, this causes tests to
fail.

This represents the null character and is tested in the PUC-Lua
test suite.

6.4.1:

> %x: (where x is any non-alphanumeric character)

For example, anchors.

6.4.1:

> The beginning and the end of the subject are handled as if they
> were the character '\0'.

6.4.1:

> A pattern item can be […] a single character class followed by
> '*' […]

Captures, balances, and frontiers are not character classes.

The previous design, while beautiful, was inefficient and not
capable of correctly handling non-greedy matching inside a tree
node. An example of this is with the common pattern for trimming
strings, `^%s*(.-)%s*$`.

A non-greedy match needs to take one token per iteration until
the *entire pattern* fails to parse, but this is not possible when
only a subtree is visible to the repetition function. Trying to
deal with this by naïve linearisation means that the edge of the
capture is lost.

I imagine that there is some technique that would allow this to
work (I am no parser expert) but the thing about Lua patterns is
that they are way too simple for this level of complexity in the
first place. So, this commit deletes the old engine and replaces it
with a hand-translation of the PUC-Lua pattern matching code which
works and passes the Lua test suite.